gnuplot 0.3 → 0.3.2

raw patch · 31 files changed

+1567/−811 lines, 31 filesdep +arraydep +containersdep +monoid-transformerdep ~basenew-component:exe:gnuplot-demo

Dependencies added: array, containers, monoid-transformer

Dependency ranges changed: base

Files

• LICENSE +25/−668
• Makefile +4/−0
• gnuplot.cabal +57/−6
• src/Demo.hs +76/−0
• src/Graphics/Gnuplot/Advanced.hs +78/−0
• src/Graphics/Gnuplot/Display.hs +59/−0
• src/Graphics/Gnuplot/Frame.hs +15/−0
• src/Graphics/Gnuplot/Frame/Option.hs +8/−0
• src/Graphics/Gnuplot/Frame/OptionSet.hs +87/−0
• src/Graphics/Gnuplot/Graph/ThreeDimensional.hs +40/−0
• src/Graphics/Gnuplot/Graph/TwoDimensional.hs +40/−0
• src/Graphics/Gnuplot/LineSpecification.hs +14/−0
• src/Graphics/Gnuplot/MultiPlot.hs +79/−0
• src/Graphics/Gnuplot/Plot/ThreeDimensional.hs +35/−0
• src/Graphics/Gnuplot/Plot/TwoDimensional.hs +73/−0
• src/Graphics/Gnuplot/Private/Frame.hs +28/−0
• src/Graphics/Gnuplot/Private/FrameOption.hs +26/−0
• src/Graphics/Gnuplot/Private/FrameOptionSet.hs +80/−0
• src/Graphics/Gnuplot/Private/Graph.hs +5/−0
• src/Graphics/Gnuplot/Private/Graph2D.hs +53/−0
• src/Graphics/Gnuplot/Private/Graph3D.hs +53/−0
• src/Graphics/Gnuplot/Private/GraphType.hs +61/−0
• src/Graphics/Gnuplot/Private/LineSpecification.hs +63/−0
• src/Graphics/Gnuplot/Private/Plot.hs +86/−0
• src/Graphics/Gnuplot/Simple.hs +151/−137
• src/Graphics/Gnuplot/Terminal.hs +18/−0
• src/Graphics/Gnuplot/Terminal/PNG.hs +91/−0
• src/Graphics/Gnuplot/Terminal/PostScript.hs +76/−0
• src/Graphics/Gnuplot/Terminal/SVG.hs +32/−0
• src/Graphics/Gnuplot/Terminal/X11.hs +49/−0
• src/Graphics/Gnuplot/Utility.hs +5/−0

@@ -1,674 +1,31 @@-                    GNU GENERAL PUBLIC LICENSE-                       Version 3, 29 June 2007-- Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>- Everyone is permitted to copy and distribute verbatim copies- of this license document, but changing it is not allowed.--                            Preamble--  The GNU General Public License is a free, copyleft license for-software and other kinds of works.--  The licenses for most software and other practical works are designed-to take away your freedom to share and change the works.  By contrast,-the GNU General Public License is intended to guarantee your freedom to-share and change all versions of a program--to make sure it remains free-software for all its users.  We, the Free Software Foundation, use the-GNU General Public License for most of our software; it applies also to-any other work released this way by its authors.  You can apply it to-your programs, too.--  When we speak of free software, we are referring to freedom, not-price.  Our General Public Licenses are designed to make sure that you-have the freedom to distribute copies of free software (and charge for-them if you wish), that you receive source code or can get it if you-want it, that you can change the software or use pieces of it in new-free programs, and that you know you can do these things.--  To protect your rights, we need to prevent others from denying you-these rights or asking you to surrender the rights.  Therefore, you have-certain responsibilities if you distribute copies of the software, or if-you modify it: responsibilities to respect the freedom of others.--  For example, if you distribute copies of such a program, whether-gratis or for a fee, you must pass on to the recipients the same-freedoms that you received.  You must make sure that they, too, receive-or can get the source code.  And you must show them these terms so they-know their rights.--  Developers that use the GNU GPL protect your rights with two steps:-(1) assert copyright on the software, and (2) offer you this License-giving you legal permission to copy, distribute and/or modify it.--  For the developers' and authors' protection, the GPL clearly explains-that there is no warranty for this free software.  For both users' and-authors' sake, the GPL requires that modified versions be marked as-changed, so that their problems will not be attributed erroneously to-authors of previous versions.--  Some devices are designed to deny users access to install or run-modified versions of the software inside them, although the manufacturer-can do so.  This is fundamentally incompatible with the aim of-protecting users' freedom to change the software.  The systematic-pattern of such abuse occurs in the area of products for individuals to-use, which is precisely where it is most unacceptable.  Therefore, we-have designed this version of the GPL to prohibit the practice for those-products.  If such problems arise substantially in other domains, we-stand ready to extend this provision to those domains in future versions-of the GPL, as needed to protect the freedom of users.--  Finally, every program is threatened constantly by software patents.-States should not allow patents to restrict development and use of-software on general-purpose computers, but in those that do, we wish to-avoid the special danger that patents applied to a free program could-make it effectively proprietary.  To prevent this, the GPL assures that-patents cannot be used to render the program non-free.--  The precise terms and conditions for copying, distribution and-modification follow.--                       TERMS AND CONDITIONS--  0. Definitions.--  "This License" refers to version 3 of the GNU General Public License.--  "Copyright" also means copyright-like laws that apply to other kinds of-works, such as semiconductor masks.--  "The Program" refers to any copyrightable work licensed under this-License.  Each licensee is addressed as "you".  "Licensees" and-"recipients" may be individuals or organizations.--  To "modify" a work means to copy from or adapt all or part of the work-in a fashion requiring copyright permission, other than the making of an-exact copy.  The resulting work is called a "modified version" of the-earlier work or a work "based on" the earlier work.--  A "covered work" means either the unmodified Program or a work based-on the Program.--  To "propagate" a work means to do anything with it that, without-permission, would make you directly or secondarily liable for-infringement under applicable copyright law, except executing it on a-computer or modifying a private copy.  Propagation includes copying,-distribution (with or without modification), making available to the-public, and in some countries other activities as well.--  To "convey" a work means any kind of propagation that enables other-parties to make or receive copies.  Mere interaction with a user through-a computer network, with no transfer of a copy, is not conveying.--  An interactive user interface displays "Appropriate Legal Notices"-to the extent that it includes a convenient and prominently visible-feature that (1) displays an appropriate copyright notice, and (2)-tells the user that there is no warranty for the work (except to the-extent that warranties are provided), that licensees may convey the-work under this License, and how to view a copy of this License.  If-the interface presents a list of user commands or options, such as a-menu, a prominent item in the list meets this criterion.--  1. Source Code.--  The "source code" for a work means the preferred form of the work-for making modifications to it.  "Object code" means any non-source-form of a work.--  A "Standard Interface" means an interface that either is an official-standard defined by a recognized standards body, or, in the case of-interfaces specified for a particular programming language, one that-is widely used among developers working in that language.--  The "System Libraries" of an executable work include anything, other-than the work as a whole, that (a) is included in the normal form of-packaging a Major Component, but which is not part of that Major-Component, and (b) serves only to enable use of the work with that-Major Component, or to implement a Standard Interface for which an-implementation is available to the public in source code form.  A-"Major Component", in this context, means a major essential component-(kernel, window system, and so on) of the specific operating system-(if any) on which the executable work runs, or a compiler used to-produce the work, or an object code interpreter used to run it.--  The "Corresponding Source" for a work in object code form means all-the source code needed to generate, install, and (for an executable-work) run the object code and to modify the work, including scripts to-control those activities.  However, it does not include the work's-System Libraries, or general-purpose tools or generally available free-programs which are used unmodified in performing those activities but-which are not part of the work.  For example, Corresponding Source-includes interface definition files associated with source files for-the work, and the source code for shared libraries and dynamically-linked subprograms that the work is specifically designed to require,-such as by intimate data communication or control flow between those-subprograms and other parts of the work.--  The Corresponding Source need not include anything that users-can regenerate automatically from other parts of the Corresponding-Source.--  The Corresponding Source for a work in source code form is that-same work.--  2. Basic Permissions.--  All rights granted under this License are granted for the term of-copyright on the Program, and are irrevocable provided the stated-conditions are met.  This License explicitly affirms your unlimited-permission to run the unmodified Program.  The output from running a-covered work is covered by this License only if the output, given its-content, constitutes a covered work.  This License acknowledges your-rights of fair use or other equivalent, as provided by copyright law.--  You may make, run and propagate covered works that you do not-convey, without conditions so long as your license otherwise remains-in force.  You may convey covered works to others for the sole purpose-of having them make modifications exclusively for you, or provide you-with facilities for running those works, provided that you comply with-the terms of this License in conveying all material for which you do-not control copyright.  Those thus making or running the covered works-for you must do so exclusively on your behalf, under your direction-and control, on terms that prohibit them from making any copies of-your copyrighted material outside their relationship with you.--  Conveying under any other circumstances is permitted solely under-the conditions stated below.  Sublicensing is not allowed; section 10-makes it unnecessary.--  3. Protecting Users' Legal Rights From Anti-Circumvention Law.--  No covered work shall be deemed part of an effective technological-measure under any applicable law fulfilling obligations under article-11 of the WIPO copyright treaty adopted on 20 December 1996, or-similar laws prohibiting or restricting circumvention of such-measures.--  When you convey a covered work, you waive any legal power to forbid-circumvention of technological measures to the extent such circumvention-is effected by exercising rights under this License with respect to-the covered work, and you disclaim any intention to limit operation or-modification of the work as a means of enforcing, against the work's-users, your or third parties' legal rights to forbid circumvention of-technological measures.--  4. Conveying Verbatim Copies.--  You may convey verbatim copies of the Program's source code as you-receive it, in any medium, provided that you conspicuously and-appropriately publish on each copy an appropriate copyright notice;-keep intact all notices stating that this License and any-non-permissive terms added in accord with section 7 apply to the code;-keep intact all notices of the absence of any warranty; and give all-recipients a copy of this License along with the Program.--  You may charge any price or no price for each copy that you convey,-and you may offer support or warranty protection for a fee.--  5. Conveying Modified Source Versions.--  You may convey a work based on the Program, or the modifications to-produce it from the Program, in the form of source code under the-terms of section 4, provided that you also meet all of these conditions:--    a) The work must carry prominent notices stating that you modified-    it, and giving a relevant date.--    b) The work must carry prominent notices stating that it is-    released under this License and any conditions added under section-    7.  This requirement modifies the requirement in section 4 to-    "keep intact all notices".--    c) You must license the entire work, as a whole, under this-    License to anyone who comes into possession of a copy.  This-    License will therefore apply, along with any applicable section 7-    additional terms, to the whole of the work, and all its parts,-    regardless of how they are packaged.  This License gives no-    permission to license the work in any other way, but it does not-    invalidate such permission if you have separately received it.--    d) If the work has interactive user interfaces, each must display-    Appropriate Legal Notices; however, if the Program has interactive-    interfaces that do not display Appropriate Legal Notices, your-    work need not make them do so.--  A compilation of a covered work with other separate and independent-works, which are not by their nature extensions of the covered work,-and which are not combined with it such as to form a larger program,-in or on a volume of a storage or distribution medium, is called an-"aggregate" if the compilation and its resulting copyright are not-used to limit the access or legal rights of the compilation's users-beyond what the individual works permit.  Inclusion of a covered work-in an aggregate does not cause this License to apply to the other-parts of the aggregate.--  6. Conveying Non-Source Forms.--  You may convey a covered work in object code form under the terms-of sections 4 and 5, provided that you also convey the-machine-readable Corresponding Source under the terms of this License,-in one of these ways:--    a) Convey the object code in, or embodied in, a physical product-    (including a physical distribution medium), accompanied by the-    Corresponding Source fixed on a durable physical medium-    customarily used for software interchange.--    b) Convey the object code in, or embodied in, a physical product-    (including a physical distribution medium), accompanied by a-    written offer, valid for at least three years and valid for as-    long as you offer spare parts or customer support for that product-    model, to give anyone who possesses the object code either (1) a-    copy of the Corresponding Source for all the software in the-    product that is covered by this License, on a durable physical-    medium customarily used for software interchange, for a price no-    more than your reasonable cost of physically performing this-    conveying of source, or (2) access to copy the-    Corresponding Source from a network server at no charge.--    c) Convey individual copies of the object code with a copy of the-    written offer to provide the Corresponding Source.  This-    alternative is allowed only occasionally and noncommercially, and-    only if you received the object code with such an offer, in accord-    with subsection 6b.--    d) Convey the object code by offering access from a designated-    place (gratis or for a charge), and offer equivalent access to the-    Corresponding Source in the same way through the same place at no-    further charge.  You need not require recipients to copy the-    Corresponding Source along with the object code.  If the place to-    copy the object code is a network server, the Corresponding Source-    may be on a different server (operated by you or a third party)-    that supports equivalent copying facilities, provided you maintain-    clear directions next to the object code saying where to find the-    Corresponding Source.  Regardless of what server hosts the-    Corresponding Source, you remain obligated to ensure that it is-    available for as long as needed to satisfy these requirements.--    e) Convey the object code using peer-to-peer transmission, provided-    you inform other peers where the object code and Corresponding-    Source of the work are being offered to the general public at no-    charge under subsection 6d.--  A separable portion of the object code, whose source code is excluded-from the Corresponding Source as a System Library, need not be-included in conveying the object code work.--  A "User Product" is either (1) a "consumer product", which means any-tangible personal property which is normally used for personal, family,-or household purposes, or (2) anything designed or sold for incorporation-into a dwelling.  In determining whether a product is a consumer product,-doubtful cases shall be resolved in favor of coverage.  For a particular-product received by a particular user, "normally used" refers to a-typical or common use of that class of product, regardless of the status-of the particular user or of the way in which the particular user-actually uses, or expects or is expected to use, the product.  A product-is a consumer product regardless of whether the product has substantial-commercial, industrial or non-consumer uses, unless such uses represent-the only significant mode of use of the product.--  "Installation Information" for a User Product means any methods,-procedures, authorization keys, or other information required to install-and execute modified versions of a covered work in that User Product from-a modified version of its Corresponding Source.  The information must-suffice to ensure that the continued functioning of the modified object-code is in no case prevented or interfered with solely because-modification has been made.--  If you convey an object code work under this section in, or with, or-specifically for use in, a User Product, and the conveying occurs as-part of a transaction in which the right of possession and use of the-User Product is transferred to the recipient in perpetuity or for a-fixed term (regardless of how the transaction is characterized), the-Corresponding Source conveyed under this section must be accompanied-by the Installation Information.  But this requirement does not apply-if neither you nor any third party retains the ability to install-modified object code on the User Product (for example, the work has-been installed in ROM).--  The requirement to provide Installation Information does not include a-requirement to continue to provide support service, warranty, or updates-for a work that has been modified or installed by the recipient, or for-the User Product in which it has been modified or installed.  Access to a-network may be denied when the modification itself materially and-adversely affects the operation of the network or violates the rules and-protocols for communication across the network.--  Corresponding Source conveyed, and Installation Information provided,-in accord with this section must be in a format that is publicly-documented (and with an implementation available to the public in-source code form), and must require no special password or key for-unpacking, reading or copying.--  7. Additional Terms.--  "Additional permissions" are terms that supplement the terms of this-License by making exceptions from one or more of its conditions.-Additional permissions that are applicable to the entire Program shall-be treated as though they were included in this License, to the extent-that they are valid under applicable law.  If additional permissions-apply only to part of the Program, that part may be used separately-under those permissions, but the entire Program remains governed by-this License without regard to the additional permissions.--  When you convey a copy of a covered work, you may at your option-remove any additional permissions from that copy, or from any part of-it.  (Additional permissions may be written to require their own-removal in certain cases when you modify the work.)  You may place-additional permissions on material, added by you to a covered work,-for which you have or can give appropriate copyright permission.--  Notwithstanding any other provision of this License, for material you-add to a covered work, you may (if authorized by the copyright holders of-that material) supplement the terms of this License with terms:--    a) Disclaiming warranty or limiting liability differently from the-    terms of sections 15 and 16 of this License; or--    b) Requiring preservation of specified reasonable legal notices or-    author attributions in that material or in the Appropriate Legal-    Notices displayed by works containing it; or--    c) Prohibiting misrepresentation of the origin of that material, or-    requiring that modified versions of such material be marked in-    reasonable ways as different from the original version; or--    d) Limiting the use for publicity purposes of names of licensors or-    authors of the material; or--    e) Declining to grant rights under trademark law for use of some-    trade names, trademarks, or service marks; or--    f) Requiring indemnification of licensors and authors of that-    material by anyone who conveys the material (or modified versions of-    it) with contractual assumptions of liability to the recipient, for-    any liability that these contractual assumptions directly impose on-    those licensors and authors.--  All other non-permissive additional terms are considered "further-restrictions" within the meaning of section 10.  If the Program as you-received it, or any part of it, contains a notice stating that it is-governed by this License along with a term that is a further-restriction, you may remove that term.  If a license document contains-a further restriction but permits relicensing or conveying under this-License, you may add to a covered work material governed by the terms-of that license document, provided that the further restriction does-not survive such relicensing or conveying.--  If you add terms to a covered work in accord with this section, you-must place, in the relevant source files, a statement of the-additional terms that apply to those files, or a notice indicating-where to find the applicable terms.--  Additional terms, permissive or non-permissive, may be stated in the-form of a separately written license, or stated as exceptions;-the above requirements apply either way.--  8. Termination.--  You may not propagate or modify a covered work except as expressly-provided under this License.  Any attempt otherwise to propagate or-modify it is void, and will automatically terminate your rights under-this License (including any patent licenses granted under the third-paragraph of section 11).--  However, if you cease all violation of this License, then your-license from a particular copyright holder is reinstated (a)-provisionally, unless and until the copyright holder explicitly and-finally terminates your license, and (b) permanently, if the copyright-holder fails to notify you of the violation by some reasonable means-prior to 60 days after the cessation.--  Moreover, your license from a particular copyright holder is-reinstated permanently if the copyright holder notifies you of the-violation by some reasonable means, this is the first time you have-received notice of violation of this License (for any work) from that-copyright holder, and you cure the violation prior to 30 days after-your receipt of the notice.--  Termination of your rights under this section does not terminate the-licenses of parties who have received copies or rights from you under-this License.  If your rights have been terminated and not permanently-reinstated, you do not qualify to receive new licenses for the same-material under section 10.--  9. Acceptance Not Required for Having Copies.--  You are not required to accept this License in order to receive or-run a copy of the Program.  Ancillary propagation of a covered work-occurring solely as a consequence of using peer-to-peer transmission-to receive a copy likewise does not require acceptance.  However,-nothing other than this License grants you permission to propagate or-modify any covered work.  These actions infringe copyright if you do-not accept this License.  Therefore, by modifying or propagating a-covered work, you indicate your acceptance of this License to do so.--  10. Automatic Licensing of Downstream Recipients.--  Each time you convey a covered work, the recipient automatically-receives a license from the original licensors, to run, modify and-propagate that work, subject to this License.  You are not responsible-for enforcing compliance by third parties with this License.--  An "entity transaction" is a transaction transferring control of an-organization, or substantially all assets of one, or subdividing an-organization, or merging organizations.  If propagation of a covered-work results from an entity transaction, each party to that-transaction who receives a copy of the work also receives whatever-licenses to the work the party's predecessor in interest had or could-give under the previous paragraph, plus a right to possession of the-Corresponding Source of the work from the predecessor in interest, if-the predecessor has it or can get it with reasonable efforts.--  You may not impose any further restrictions on the exercise of the-rights granted or affirmed under this License.  For example, you may-not impose a license fee, royalty, or other charge for exercise of-rights granted under this License, and you may not initiate litigation-(including a cross-claim or counterclaim in a lawsuit) alleging that-any patent claim is infringed by making, using, selling, offering for-sale, or importing the Program or any portion of it.--  11. Patents.--  A "contributor" is a copyright holder who authorizes use under this-License of the Program or a work on which the Program is based.  The-work thus licensed is called the contributor's "contributor version".--  A contributor's "essential patent claims" are all patent claims-owned or controlled by the contributor, whether already acquired or-hereafter acquired, that would be infringed by some manner, permitted-by this License, of making, using, or selling its contributor version,-but do not include claims that would be infringed only as a-consequence of further modification of the contributor version.  For-purposes of this definition, "control" includes the right to grant-patent sublicenses in a manner consistent with the requirements of-this License.--  Each contributor grants you a non-exclusive, worldwide, royalty-free-patent license under the contributor's essential patent claims, to-make, use, sell, offer for sale, import and otherwise run, modify and-propagate the contents of its contributor version.--  In the following three paragraphs, a "patent license" is any express-agreement or commitment, however denominated, not to enforce a patent-(such as an express permission to practice a patent or covenant not to-sue for patent infringement).  To "grant" such a patent license to a-party means to make such an agreement or commitment not to enforce a-patent against the party.--  If you convey a covered work, knowingly relying on a patent license,-and the Corresponding Source of the work is not available for anyone-to copy, free of charge and under the terms of this License, through a-publicly available network server or other readily accessible means,-then you must either (1) cause the Corresponding Source to be so-available, or (2) arrange to deprive yourself of the benefit of the-patent license for this particular work, or (3) arrange, in a manner-consistent with the requirements of this License, to extend the patent-license to downstream recipients.  "Knowingly relying" means you have-actual knowledge that, but for the patent license, your conveying the-covered work in a country, or your recipient's use of the covered work-in a country, would infringe one or more identifiable patents in that-country that you have reason to believe are valid.--  If, pursuant to or in connection with a single transaction or-arrangement, you convey, or propagate by procuring conveyance of, a-covered work, and grant a patent license to some of the parties-receiving the covered work authorizing them to use, propagate, modify-or convey a specific copy of the covered work, then the patent license-you grant is automatically extended to all recipients of the covered-work and works based on it.--  A patent license is "discriminatory" if it does not include within-the scope of its coverage, prohibits the exercise of, or is-conditioned on the non-exercise of one or more of the rights that are-specifically granted under this License.  You may not convey a covered-work if you are a party to an arrangement with a third party that is-in the business of distributing software, under which you make payment-to the third party based on the extent of your activity of conveying-the work, and under which the third party grants, to any of the-parties who would receive the covered work from you, a discriminatory-patent license (a) in connection with copies of the covered work-conveyed by you (or copies made from those copies), or (b) primarily-for and in connection with specific products or compilations that-contain the covered work, unless you entered into that arrangement,-or that patent license was granted, prior to 28 March 2007.--  Nothing in this License shall be construed as excluding or limiting-any implied license or other defenses to infringement that may-otherwise be available to you under applicable patent law.--  12. No Surrender of Others' Freedom.--  If conditions are imposed on you (whether by court order, agreement or-otherwise) that contradict the conditions of this License, they do not-excuse you from the conditions of this License.  If you cannot convey a-covered work so as to satisfy simultaneously your obligations under this-License and any other pertinent obligations, then as a consequence you may-not convey it at all.  For example, if you agree to terms that obligate you-to collect a royalty for further conveying from those to whom you convey-the Program, the only way you could satisfy both those terms and this-License would be to refrain entirely from conveying the Program.--  13. Use with the GNU Affero General Public License.--  Notwithstanding any other provision of this License, you have-permission to link or combine any covered work with a work licensed-under version 3 of the GNU Affero General Public License into a single-combined work, and to convey the resulting work.  The terms of this-License will continue to apply to the part which is the covered work,-but the special requirements of the GNU Affero General Public License,-section 13, concerning interaction through a network will apply to the-combination as such.--  14. Revised Versions of this License.--  The Free Software Foundation may publish revised and/or new versions of-the GNU 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-Program specifies that a certain numbered version of the GNU General-Public License "or any later version" applies to it, you have the-option of following the terms and conditions either of that numbered-version or of any later version published by the Free Software-Foundation.  If the Program does not specify a version number of the-GNU General Public License, you may choose any version ever published-by the Free Software Foundation.--  If the Program specifies that a proxy can decide which future-versions of the GNU General Public License can be used, that proxy's-public statement of acceptance of a version permanently authorizes you-to choose that version for the Program.--  Later license versions may give you additional or different-permissions.  However, no additional obligations are imposed on any-author or copyright holder as a result of your choosing to follow a-later version.--  15. Disclaimer of Warranty.--  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY-APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT-HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY-OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,-THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR-PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM-IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF-ALL NECESSARY SERVICING, REPAIR OR CORRECTION.--  16. Limitation of Liability.--  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING-WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS-THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY-GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE-USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF-DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD-PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),-EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF-SUCH DAMAGES.--  17. Interpretation of Sections 15 and 16.--  If the disclaimer of warranty and limitation of liability provided-above cannot be given local legal effect according to their terms,-reviewing courts shall apply local law that most closely approximates-an absolute waiver of all civil liability in connection with the-Program, unless a warranty or assumption of liability accompanies a-copy of the Program in return for a fee.--                     END OF TERMS AND CONDITIONS--            How to Apply These Terms to Your New Programs--  If you develop a new program, and you want it to be of the greatest-possible use to the public, the best way to achieve this is to make it-free software which everyone can redistribute and change under these terms.--  To do so, attach the following notices to the program.  It is safest-to attach them to the start of each source file to most effectively-state the exclusion of warranty; and each file should have at least-the "copyright" line and a pointer to where the full notice is found.--    <one line to give the program's name and a brief idea of what it does.>-    Copyright (C) <year>  <name of author>--    This program is free software: you can redistribute it and/or modify-    it under the terms of the GNU General Public License as published by-    the Free Software Foundation, either version 3 of the License, or-    (at your option) any later version.--    This program is distributed in the hope that it will be useful,-    but WITHOUT ANY WARRANTY; without even the implied warranty of-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the-    GNU General Public License for more details.--    You should have received a copy of the GNU General Public License-    along with this program.  If not, see <http://www.gnu.org/licenses/>.+Copyright (c) 2009, Henning Thielemann -Also add information on how to contact you by electronic and paper mail.+All rights reserved. -  If the program does terminal interaction, make it output a short-notice like this when it starts in an interactive mode:+Redistribution and use in source and binary forms, with or without+modification, are permitted provided that the following conditions are+met: -    <program>  Copyright (C) <year>  <name of author>-    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.-    This is free software, and you are welcome to redistribute it-    under certain conditions; type `show c' for details.+    * Redistributions of source code must retain the above copyright+      notice, this list of conditions and the following disclaimer. -The hypothetical commands `show w' and `show c' should show the appropriate-parts of the General Public License.  Of course, your program's commands-might be different; for a GUI interface, you would use an "about box".+    * Redistributions in binary form must reproduce the above+      copyright notice, this list of conditions and the following+      disclaimer in the documentation and/or other materials provided+      with the distribution. -  You should also get your employer (if you work as a programmer) or school,-if any, to sign a "copyright disclaimer" for the program, if necessary.-For more information on this, and how to apply and follow the GNU GPL, see-<http://www.gnu.org/licenses/>.+    * The names of contributors may not be used to endorse or promote+      products derived from this software without specific prior+      written permission. -  The GNU General Public License does not permit incorporating your program-into proprietary programs.  If your program is a subroutine library, you-may consider it more useful to permit linking proprietary applications with-the library.  If this is what you want to do, use the GNU Lesser General-Public License instead of this License.  But first, please read-<http://www.gnu.org/philosophy/why-not-lgpl.html>.+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

@@ -8,3 +8,7 @@  ghci-shell: 	ghci -Wall -i:src:execute/shell src/Graphics/Gnuplot/Simple.hs++ghci-demo:+	ghci -Wall -i:src:execute/tmp src/Demo.hs+

@@ -1,6 +1,6 @@ Name:             gnuplot-Version:          0.3-License:          GPL+Version:          0.3.2+License:          BSD3 License-File:     LICENSE Author:           Henning Thielemann <haskell@henning-thielemann.de> Maintainer:       Henning Thielemann <haskell@henning-thielemann.de>@@ -12,13 +12,20 @@    This is a wrapper to gnuplot    which lets you create 2D and 3D plots.    .+   Start a simple session with @make ghci@.+   This loads the module "Graphics.Gnuplot.Simple"+   which is ready for use in GHCi.+   It does not address all fancy gnuplot features+   in order to stay simple.+   For more sophisticated plots,+   especially batch generated graphics,+   I recommend "Graphics.Gnuplot.Advanced".+   .    With the Cabal flags executePipe and executeShell    you can switch to more convenient    but probably less portable ways    of running gnuplot.    .-   Start a simple session with @make ghci@.-   .    In the past this was part of the htam package. Tested-With:       GHC==6.8.2 Cabal-Version:     >=1.2@@ -36,6 +43,10 @@   description: Build test executables   default:     False +Flag buildExamples+  description: Build example executables+  default:     False+ Flag executePipe   description: Avoid a temporary gnuplot script by running gnuplot with runInteractiveProcess   default:     False@@ -45,9 +56,17 @@   default:     False  Library-  Build-Depends: utility-ht >= 0.0.1 && < 0.1+  Build-Depends:+    array >= 0.1 && <0.3,+    containers >= 0.1 && <0.3,+    utility-ht >= 0.0.1 && < 0.1,+    monoid-transformer >= 0.0.2 && <0.1   If flag(splitBase)-    Build-Depends: base >= 2, process >= 1.0 && < 1.1, time >= 1.1 && < 1.2, old-locale >= 1.0 && < 1.1+    Build-Depends:+      base >= 2 && <5,+      process >= 1.0 && < 1.1,+      time >= 1.1 && < 1.2,+      old-locale >= 1.0 && < 1.1   Else     Build-Depends: base >= 1.0 && < 2 @@ -65,6 +84,38 @@   Exposed-Modules:     Graphics.Gnuplot.Simple     Graphics.Gnuplot.Time+    Graphics.Gnuplot.Advanced+    Graphics.Gnuplot.Terminal.PostScript+    Graphics.Gnuplot.Terminal.PNG+    Graphics.Gnuplot.Terminal.SVG+    Graphics.Gnuplot.Terminal.X11+    Graphics.Gnuplot.Frame+    Graphics.Gnuplot.Frame.Option+    Graphics.Gnuplot.Frame.OptionSet+    Graphics.Gnuplot.Plot.TwoDimensional+    Graphics.Gnuplot.Plot.ThreeDimensional+    Graphics.Gnuplot.Graph.TwoDimensional+    Graphics.Gnuplot.Graph.ThreeDimensional+    Graphics.Gnuplot.LineSpecification+    Graphics.Gnuplot.MultiPlot   Other-Modules:+    Graphics.Gnuplot.Private.LineSpecification+    Graphics.Gnuplot.Private.Plot+    Graphics.Gnuplot.Private.Frame+    Graphics.Gnuplot.Private.FrameOption+    Graphics.Gnuplot.Private.FrameOptionSet+    Graphics.Gnuplot.Private.GraphType+    Graphics.Gnuplot.Private.Graph+    Graphics.Gnuplot.Private.Graph2D+    Graphics.Gnuplot.Private.Graph3D     Graphics.Gnuplot.Utility     Graphics.Gnuplot.Execute+    Graphics.Gnuplot.Display+    Graphics.Gnuplot.Terminal++Executable gnuplot-demo+  If !flag(buildExamples)+    Buildable: False+  GHC-Options: -Wall+  Hs-Source-Dirs: src, execute/tmp+  Main-Is: Demo.hs

@@ -0,0 +1,76 @@+module Main where++import qualified Graphics.Gnuplot.Advanced as Plot+import qualified Graphics.Gnuplot.Terminal.X11 as X11++import qualified Graphics.Gnuplot.MultiPlot as MultiPlot++import qualified Graphics.Gnuplot.Frame as Frame+import qualified Graphics.Gnuplot.Frame.Option as Opt+import qualified Graphics.Gnuplot.Frame.OptionSet as Opts++import qualified Graphics.Gnuplot.Plot.ThreeDimensional as Plot3D++import qualified Graphics.Gnuplot.Plot.TwoDimensional as Plot2D+import qualified Graphics.Gnuplot.Graph.TwoDimensional as Graph2D+import Graphics.Gnuplot.Plot.TwoDimensional (linearScale, )++import Data.Array (listArray, )+import Data.Monoid (mappend, )+++simple2d :: Plot2D.T+simple2d =+   Plot2D.function (linearScale 100 (-10,10::Double)) sin++circle2d :: Plot2D.T+circle2d =+   fmap+      (Graph2D.typ Graph2D.points)+      (Plot2D.parameterFunction+         (linearScale 24 (-pi,pi::Double))+         (\t -> (cos t, sin t)))++overlay2d :: Frame.T Graph2D.T+overlay2d =+   Frame.cons (Opts.size 1 0.4 $ Opts.remove Opt.key $ Opts.deflt) $+   Plot2D.function (linearScale 100 (-pi,pi::Double)) cos+   `mappend`+   circle2d++multiplot2d :: MultiPlot.T+multiplot2d =+   let opts :: Opts.T graph+       opts =+          Opts.remove Opt.key $+          Opts.deflt+       (prefix,suffix) =+          splitAt 7 $+          map MultiPlot.partFromFrame $+          map (\k ->+             Frame.cons (Opts.xRange (-1,1) opts) $+             Plot2D.parameterFunction+                (linearScale 48 (-pi,pi::Double))+                (\t -> (cos (t + pi/7*fromInteger k), sin (2*t)))) $+          [0..13]+       meshNodes = linearScale 20 (-2,2::Double)+       center =+          MultiPlot.partFromFrame $+          Frame.cons+             (Opts.xRange (-2.5,2.5) $+              Opts.yRange (-2.5,2.5) $+              opts) $+          (Plot3D.function+             meshNodes meshNodes+             (\x y -> cos(x*x+y*y)))+   in  MultiPlot.simpleFromPartArray $+       listArray ((0::Int,0::Int), (2,4)) $+       prefix ++ center : suffix+++main :: IO ()+main =+   do Plot.plot X11.cons simple2d+      Plot.plot X11.cons overlay2d+      Plot.plot X11.cons multiplot2d+      return ()

@@ -0,0 +1,78 @@+{- |+Modularized interface to gnuplot+that allows complex graphics and fine control of their components.+It is designed for non-interactive use,+e.g. scripts for plotting statistics.++The hierarchy of objects is as follows:++* @Graph2D@: A curve like a sine curve.+  Attributes of a graph are line type, thickness, color.++* @Graph3D@: A surface.++* @Plot@: An overlay of many curves.+  It is parametrized by the graph type (2D or 3D)+  in order to make sure,+  that only graphs of one type are overlayed+  and only according attributes can be accessed.+  You cannot generate plots or graphs alone,+  you can only generate plots containing graphs+  using the functions in "Graphics.Gnuplot.Plot.TwoDimensional"+  and "Graphics.Gnuplot.Plot.ThreeDimensional".+  You can combine plots using the 'Monoid' type class.++* @Frame@: Add options to a plot+  such as border, legend, title, label attributes.+  See "Graphics.Gnuplot.Frame".++* @MultiPlot@: Arrange several frames in a matrix layout.+  See "Graphics.Gnuplot.MultiPlot".+-}+module Graphics.Gnuplot.Advanced (+    plot,+  ) where++import qualified Graphics.Gnuplot.Private.FrameOptionSet as OptionSet+import qualified Graphics.Gnuplot.Display as Display++import qualified Graphics.Gnuplot.Terminal as Terminal+import qualified Graphics.Gnuplot.Execute as Exec++import System.Exit (ExitCode, )+import Data.Monoid (Monoid, ) -- for Haddock+import qualified Data.Monoid.State as State+import Data.List (intersperse, )+++-- * User front-end+++{- |+The plot function returns 'ExitCode',+which is nice for programming+but ugly for interactive GHCi sessions.+For interactive sessions,+better use "Graphics.Gnuplot.Simple".+@gfx@ must be one of the types @Plot@, @Frame@, @MultiPlot@.+-}+plot ::+   (Terminal.C terminal, Display.C gfx) =>+   terminal -> gfx -> IO ExitCode+plot term gfx =+   let body =+          State.evaluate (0, OptionSet.decons OptionSet.deflt) $+          Display.runScript $+          Display.toScript gfx+   in  do mapM_ Display.writeData (Display.files body)+          Exec.simple+             (formatTerminal term : Display.commands body)+             ["-persist"]++formatTerminal ::+   (Terminal.C terminal) =>+   terminal -> String+formatTerminal term =+   let (Terminal.Cons options commands) = Terminal.canonical term+   in  concat $ intersperse "; " $+          ("set terminal " ++ unwords options) : commands

@@ -0,0 +1,59 @@+{- |+This class allows gives a uniform interface to plotting+@Plot@, @Frame@ and @MultiPlot@.+-}+module Graphics.Gnuplot.Display where++import qualified Graphics.Gnuplot.Private.FrameOption as Option++import qualified Data.Map as Map+import qualified Data.Monoid.State as State+import Data.Monoid (Monoid, mempty, mappend, )+++-- * User front-end++newtype Script =+   Script {+      runScript :: State.T (Int, OptionSet) Body+   }++data Body =+   Body {+      files :: [File],+      commands :: [String]+   }++type OptionSet = Map.Map Option.T [String]++data File =+   File {+      filename :: FilePath,+      content :: String+   }++writeData :: File -> IO ()+writeData (File fn cont) =+   writeFile fn cont+++{-+Could also be implemented with Control.Monad.Trans.State:+mappend = liftA2 mappend+-}+instance Monoid Script where+   mempty = Script mempty+   mappend (Script b0) (Script b1) =+      Script (mappend b0 b1)++{-+Could also be implemented with Control.Monad.Trans.State:+mappend = liftA2 mappend+-}+instance Monoid Body where+   mempty = Body mempty mempty+   mappend (Body f0 c0) (Body f1 c1) =+      Body (mappend f0 f1) (mappend c0 c1)++class C gfx where+   toScript :: gfx -> Script

@@ -0,0 +1,15 @@+module Graphics.Gnuplot.Frame (+   Frame.T,+   cons, simple,+   ) where++import qualified Graphics.Gnuplot.Private.Frame as Frame+import qualified Graphics.Gnuplot.Private.Plot as Plot+import qualified Graphics.Gnuplot.Private.FrameOptionSet as Option+++cons :: Option.T graph -> Plot.T graph -> Frame.T graph+cons = Frame.Cons++simple :: Plot.T graph -> Frame.T graph+simple = cons Option.deflt

@@ -0,0 +1,8 @@+module Graphics.Gnuplot.Frame.Option (+   Option.T,+   module Graphics.Gnuplot.Private.FrameOption,+   ) where++-- exclude Cons constructor+import Graphics.Gnuplot.Private.FrameOption hiding (T)+import qualified Graphics.Gnuplot.Private.FrameOption as Option

@@ -0,0 +1,87 @@+module Graphics.Gnuplot.Frame.OptionSet (+   OptionSet.T,+   OptionSet.deflt,++   OptionSet.add,+   OptionSet.remove,++   size,+   title,+   xRange,+   yRange,+   zRange,+   xLabel,+   yLabel,+   zLabel,+   ) where+++import qualified Graphics.Gnuplot.Graph.ThreeDimensional as Graph3D++import qualified Graphics.Gnuplot.Private.FrameOptionSet as OptionSet+import qualified Graphics.Gnuplot.Private.FrameOption as Option+import qualified Graphics.Gnuplot.Private.Graph as Graph++import Graphics.Gnuplot.Private.FrameOptionSet (T, )++import Graphics.Gnuplot.Utility+   (quote, )+++size :: Graph.C graph => Double -> Double -> T graph -> T graph+size x y =+   OptionSet.add Option.size [show x ++ ", " ++ show y]++title :: Graph.C graph => String -> T graph -> T graph+title text =+   OptionSet.add Option.title [quote text]+++xRange :: Graph.C graph => (Double, Double) -> T graph -> T graph+xRange = range Option.xRange++yRange :: Graph.C graph => (Double, Double) -> T graph -> T graph+yRange = range Option.yRange++zRange :: (Double, Double) -> T Graph3D.T -> T Graph3D.T+zRange = range Option.zRange++range :: Graph.C graph => Option.T -> (Double, Double) -> T graph -> T graph+range opt (x,y) =+   OptionSet.add opt ["[" ++ show x ++ ":" ++ show y ++ "]"]+++xLabel :: Graph.C graph => String -> T graph -> T graph+xLabel = label Option.xLabel++yLabel :: Graph.C graph => String -> T graph -> T graph+yLabel = label Option.yLabel++zLabel :: String -> T Graph3D.T -> T Graph3D.T+zLabel = label Option.zLabel++label :: Graph.C graph => Option.T -> String -> T graph -> T graph+label opt x =+   OptionSet.add opt [quote x]+++{-+xTicks :: Graph.C graph => Double -> Double -> T graph -> T graph+xTicks = ticks Option.xTicks++yTicks :: Graph.C graph => Double -> Double -> T graph -> T graph+yTicks = ticks Option.yTicks++zTicks :: Double -> Double -> T Graph3D.T -> T Graph3D.T+zTicks = ticks Option.zTicks++ticks :: Graph.C graph => Option.T -> Double -> Double -> T graph -> T graph+ticks opt x y =+   OptionSet.add opt [show x ++ ":" ++ show y]+-}++{-+cornerToColor :: CornersToColor -> T Graph3D.T -> T Graph3D.T++type3d :: Plot3dType -> T Graph3D.T -> T Graph3D.T+-}

@@ -0,0 +1,40 @@+module Graphics.Gnuplot.Graph.ThreeDimensional (+   T,+   Type,++   defaultType,+   deflt,++   typ,+   lineSpec,++   lines,+   points,+   linesPoints,+   impulses,+   dots,+   steps,+   fSteps,+   hiSteps,+   errorBars,+   xErrorBars,+   yErrorBars,+   xyErrorBars,+   errorLines,+   xErrorLines,+   yErrorLines,+   xyErrorLines,+   boxes,+   filledCurves,+   boxErrorBars,+   boxXYErrorBars,+   financeBars,+   candleSticks,+   vectors,+   pm3d,+   ) where++import Graphics.Gnuplot.Private.Graph3D+import Graphics.Gnuplot.Private.GraphType hiding (T, )++import Prelude hiding (lines, )

@@ -0,0 +1,40 @@+module Graphics.Gnuplot.Graph.TwoDimensional (+   T,+   Type,++   defaultType,+   deflt,++   typ,+   lineSpec,++   lines,+   points,+   linesPoints,+   impulses,+   dots,+   steps,+   fSteps,+   hiSteps,+   errorBars,+   xErrorBars,+   yErrorBars,+   xyErrorBars,+   errorLines,+   xErrorLines,+   yErrorLines,+   xyErrorLines,+   boxes,+   filledCurves,+   boxErrorBars,+   boxXYErrorBars,+   financeBars,+   candleSticks,+   vectors,+   -- pm3d,+   ) where++import Graphics.Gnuplot.Private.Graph2D+import Graphics.Gnuplot.Private.GraphType hiding (T, )++import Prelude hiding (lines, )

@@ -0,0 +1,14 @@+module Graphics.Gnuplot.LineSpecification (+   T,++   deflt,++   lineStyle,+   lineType,+   lineWidth,+   pointType,+   pointSize,+   title,+   ) where++import Graphics.Gnuplot.Private.LineSpecification

@@ -0,0 +1,79 @@+module Graphics.Gnuplot.MultiPlot (+   T,+   Part,+   partFromFrame,+   partFromPlot,+   simpleFromFrameArray,+   simpleFromPartArray,+   ) where++import qualified Graphics.Gnuplot.Private.Frame as Frame+import qualified Graphics.Gnuplot.Private.Plot as Plot++import qualified Graphics.Gnuplot.Display as Display+import qualified Graphics.Gnuplot.Private.Graph as Graph++import qualified Data.Monoid.State as State+import Data.Monoid (mconcat, )++import Data.Array (Array, elems, bounds, )+import Data.Ix (Ix, rangeSize, )+++data T =+   Cons {+      _option :: (),  -- to be extended by multiplot options+      numRows, numColumns :: Int,+      parts :: [Part]+   }++newtype Part = Part {scriptFromPart :: Display.Script}++{-+We could generalize this to Frame and Plot+but MultiPlot itself cannot be made a part.+Thus the parameter cannot be generalized to+@Display.C gfx => gfx@.+-}+partFromFrame :: Graph.C graph => Frame.T graph -> Part+partFromFrame =+   Part . Display.toScript++partFromPlot :: Graph.C graph => Plot.T graph -> Part+partFromPlot =+   Part . Display.toScript+++{-+The @simple@ prefix is for functions+that don't accept custom options.+Options have to be implemented, yet.+-}+simpleFromFrameArray ::+   (Graph.C graph, Ix i, Ix j) =>+   Array (i,j) (Frame.T graph) -> T+simpleFromFrameArray =+   simpleFromPartArray . fmap partFromFrame++simpleFromPartArray ::+   (Ix i, Ix j) =>+   Array (i,j) Part -> T+simpleFromPartArray arr =+   let ((r0,c0), (r1,c1)) = bounds arr+   in  Cons ()+          (rangeSize (r0,r1))+          (rangeSize (c0,c1))+          (elems arr)+++instance Display.C T where+   toScript mp =+      mconcat $+      (Display.Script $ State.pure $+         Display.Body [] ["set multiplot layout " +++                      show (numRows mp) ++ ", " +++                      show (numColumns mp)]) :+      (map scriptFromPart $ parts mp) +++      (Display.Script $ State.pure $+         Display.Body [] ["unset multiplot"]) :+      []

@@ -0,0 +1,35 @@+module Graphics.Gnuplot.Plot.ThreeDimensional (+   linearScale,+   module Graphics.Gnuplot.Plot.ThreeDimensional,+   ) where++import qualified Graphics.Gnuplot.Private.Graph3D as Graph+import qualified Graphics.Gnuplot.Private.Plot    as Plot++import Graphics.Gnuplot.Utility+   (showTriplet, linearScale, )++import Data.List.HT (outerProduct, )+++{- |+Plots can be assembled using 'mappend' or 'mconcat'.+-}+type T = Plot.T Graph.T+++-- * computed plots++mesh ::+   (Show a, Show b, Show c) =>+   [[(a,b,c)]] -> T+mesh dat =+   Plot.withUniqueFile+      (unlines (map (unlines . map showTriplet) dat))+      [Graph.deflt (Graph.Dim3 1 2 3)]++function ::+   (Show a, Show b, Show c) =>+   [b] -> [c] -> (b -> c -> a) -> T+function xArgs yArgs f =+   mesh (outerProduct (\x y -> (x, y, f x y)) xArgs yArgs)

@@ -0,0 +1,73 @@+-- shall this also export Graph.Type, set plotType and so on?+module Graphics.Gnuplot.Plot.TwoDimensional (+   linearScale,+   module Graphics.Gnuplot.Plot.TwoDimensional,+   ) where++import qualified Graphics.Gnuplot.Private.Graph2D as Graph+import qualified Graphics.Gnuplot.Private.Plot    as Plot++import Graphics.Gnuplot.Utility+   (functionToGraph, commaConcat, linearScale, )++import qualified Data.List.Match as Match+++{- |+Plots can be assembled using 'mappend' or 'mconcat'.+-}+type T = Plot.T Graph.T+++-- * computed plots++{- |+> list (take 30 (let fibs = 0 : 1 : zipWith (+) fibs (tail fibs) in fibs))+-}+list :: Show a => [a] -> T+list dat =+   Plot.withUniqueFile+      (unlines (map show dat))+      ([Graph.deflt (Graph.Dim1 1)])++{- |+> function (linearScale 1000 (-10,10)) sin+-}+function :: Show a => [a] -> (a -> a) -> T+function args f =+   path (functionToGraph args f)++{- |+> functions (linearScale 1000 (-10,10)) [sin, cos]+-}+functions :: Show a => [a] -> [a -> a] -> T+functions args fs =+   let dat = map (\x -> (x, map ($ x) fs)) args+   in  Plot.withUniqueFile+          (unlines (map (commaConcat . map show . uncurry (:)) dat))+          (Match.take fs $+           map (Graph.deflt . Graph.Dim2 1) [2..])++path :: Show a => [(a,a)] -> T+path dat =+   Plot.withUniqueFile+      (unlines (map (\(x,y) -> show x ++ ", " ++ show y) dat))+      ([Graph.deflt (Graph.Dim2 1 2)])++{- |+> parameterFunction (linearScale 1000 (0,2*pi)) (\t -> (sin (2*t), cos t))+-}+parameterFunction :: Show a => [a] -> (a -> (a,a)) -> T+parameterFunction args f = path (map f args)++++-- * plot stored data++listFromFile :: FilePath -> Int -> T+listFromFile filename column =+   Plot.fromGraphs filename [Graph.deflt (Graph.Dim1 column)]++pathFromFile :: FilePath -> Int -> Int -> T+pathFromFile filename columnX columnY =+   Plot.fromGraphs filename [Graph.deflt (Graph.Dim2 columnX columnY)]

@@ -0,0 +1,28 @@+module Graphics.Gnuplot.Private.Frame where++import qualified Graphics.Gnuplot.Private.Plot as Plot+import qualified Graphics.Gnuplot.Private.FrameOptionSet as OptionSet++import qualified Graphics.Gnuplot.Display as Display+import qualified Graphics.Gnuplot.Private.Graph as Graph++import qualified Data.Monoid.State as State+import Data.Monoid (Monoid, mappend, )+++data T graph =+   Cons {+      option :: OptionSet.T graph,+      plot :: Plot.T graph+   }++instance Graph.C graph => Display.C (T graph) where+   toScript frame =+      (Display.Script $+         State.Cons $ \(n, opts0) ->+            let opts1 = option frame+            in  (Display.Body [] $+                 OptionSet.diffToString (OptionSet.Cons opts0) opts1,+                 (n, OptionSet.decons opts1)))+      `mappend`+      (Display.toScript $ plot frame)

@@ -0,0 +1,26 @@+module Graphics.Gnuplot.Private.FrameOption where++newtype T = Cons String+   deriving (Eq, Ord, Show)++custom :: String -> T+custom = Cons++title  :: T; title  = Cons "title"+grid   :: T; grid   = Cons "grid"+size   :: T; size   = Cons "size"+key    :: T; key    = Cons "key"+border :: T; border = Cons "border"+pm3d   :: T; pm3d   = Cons "pm3d"++xRange :: T; xRange = Cons "xrange"+yRange :: T; yRange = Cons "yrange"+zRange :: T; zRange = Cons "zrange"++xLabel :: T; xLabel = Cons "xlabel"+yLabel :: T; yLabel = Cons "ylabel"+zLabel :: T; zLabel = Cons "zlabel"++xTicks :: T; xTicks = Cons "xtics"+yTicks :: T; yTicks = Cons "ytics"+zTicks :: T; zTicks = Cons "ztics"

@@ -0,0 +1,80 @@+{-+This controls gnuplot variables for a plot.+We use a separate data type for that purpose+in order to be able to share a set of options between different plots.+(If we would only allow to set options of a frame,+e.g. border :: Bool -> Frame -> Frame,+we could of course still build+an options setting function of type Frame -> Frame+from smaller option setters.)+-}+module Graphics.Gnuplot.Private.FrameOptionSet where++import qualified Graphics.Gnuplot.Private.FrameOption as Option++import qualified Data.Map as Map++import Data.Maybe.HT (toMaybe, )+import Data.Maybe (mapMaybe, )+++newtype T graph =+   Cons {decons :: Map.Map Option.T [String]}++{- |+The default options contain what we expect as default value in gnuplot.+We need an entry for every option+that cannot be reset by @unset@.+-}+deflt :: T graph+deflt =+   Cons $ Map.fromList $+   (Option.key, []) :+   (Option.border, []) :+   (Option.xLabel, []) :+   (Option.yLabel, []) :+   (Option.zLabel, []) :+   (Option.xRange, ["[*:*]"]) :+   (Option.yRange, ["[*:*]"]) :+   (Option.zRange, ["[*:*]"]) :+   (Option.xTicks, []) :+   (Option.yTicks, []) :+   (Option.zTicks, []) :+   []+++{- |+Add an option with arguments as plain strings.+This is very flexible, but not very safe.+Use it only as fall-back,+if there is no specific setter function in "Graphics.Gnuplot.Frame.OptionSet".+-}+add :: Option.T -> [String] -> T graph -> T graph+add opt args (Cons m) =+   Cons (Map.insert opt args m)++{- |+Remove an option.+-}+remove :: Option.T -> T graph -> T graph+remove opt (Cons m) =+   Cons (Map.delete opt m)++{- |+Convert the difference between the first and the second option set+into a sequence of 'set' and 'unset' commands.+-}+diffToString :: T graph -> T graph -> [String]+diffToString (Cons m0) (Cons m1) =+   mapMaybe+      (\(Option.Cons opt, (old,new)) ->+         toMaybe (old/=new) $+         maybe+            ("unset " ++ opt)+            (\args -> "set " ++ opt ++ " " ++ unwords args)+            new) $+   Map.toList $+   Map.unionWith+      (\(old,_) (_,new) -> (old,new))+      (fmap (\x -> (Just x, Nothing)) m0)+      (fmap (\x -> (Nothing, Just x)) m1)

@@ -0,0 +1,5 @@+module Graphics.Gnuplot.Private.Graph where++class C graph where+   command :: graph -> String+   toString :: graph -> String

@@ -0,0 +1,53 @@+module Graphics.Gnuplot.Private.Graph2D where++import qualified Graphics.Gnuplot.Private.LineSpecification as LineSpec+import qualified Graphics.Gnuplot.Private.GraphType as GraphType+import qualified Graphics.Gnuplot.Private.Graph as Graph++import Prelude hiding (lines, )+++data T =+   Cons {+      column_   :: Column,+      type_     :: Type,+      lineSpec_ :: LineSpec.T+   }++data Column =+     Dim1 {columnX :: Int}+   | Dim2 {columnX, columnY :: Int}+++type Type = GraphType.T+++columnToString :: Column -> String+columnToString c =+   case c of+      Dim1 x -> show x+      Dim2 x y -> show x ++ ":" ++ show y++toString :: T -> String+toString (Cons c t l) =+   "using " ++ columnToString c +++   " with " ++ GraphType.toString t +++   " " ++ LineSpec.toString l++instance Graph.C T where+   command _ = "plot"+   toString = toString+++defaultType :: Type+defaultType = GraphType.lines++deflt :: Column -> T+deflt c = Cons c defaultType LineSpec.deflt+++typ :: Type -> T -> T+typ t gr = gr{type_ = t}++lineSpec :: LineSpec.T -> T -> T+lineSpec ls gr = gr{lineSpec_ = ls}

@@ -0,0 +1,53 @@+module Graphics.Gnuplot.Private.Graph3D where++import qualified Graphics.Gnuplot.Private.LineSpecification as LineSpec+import qualified Graphics.Gnuplot.Private.GraphType as GraphType+import qualified Graphics.Gnuplot.Private.Graph as Graph++import Prelude hiding (lines, )+++data T =+   Cons {+      column_   :: Column,+      type_     :: Type,+      lineSpec_ :: LineSpec.T+   }++data Column =+     Dim3 {columnX, columnY, columnZ :: Int}+   | Dim4 {columnX, columnY, columnZ, columnC :: Int}+++type Type = GraphType.T+++columnToString :: Column -> String+columnToString col =+   case col of+      Dim3 x y z -> show x ++ ":" ++ show y ++ ":" ++ show z+      Dim4 x y z c -> show x ++ ":" ++ show y ++ ":" ++ show z ++ ":" ++ show c++toString :: T -> String+toString (Cons c t l) =+   "using " ++ columnToString c +++   " with " ++ GraphType.toString t +++   " " ++ LineSpec.toString l++instance Graph.C T where+   command _ = "splot"+   toString = toString+++defaultType :: Type+defaultType = GraphType.pm3d++deflt :: Column -> T+deflt c = Cons c defaultType LineSpec.deflt+++typ :: Type -> T -> T+typ t gr = gr{type_ = t}++lineSpec :: LineSpec.T -> T -> T+lineSpec ls gr = gr{lineSpec_ = ls}

@@ -0,0 +1,61 @@+module Graphics.Gnuplot.Private.GraphType where++import Prelude hiding (lines, )+++newtype T = Cons String+++lines          :: T+points         :: T+linesPoints    :: T+impulses       :: T+dots           :: T+steps          :: T+fSteps         :: T+hiSteps        :: T+errorBars      :: T+xErrorBars     :: T+yErrorBars     :: T+xyErrorBars    :: T+errorLines     :: T+xErrorLines    :: T+yErrorLines    :: T+xyErrorLines   :: T+boxes          :: T+filledCurves   :: T+boxErrorBars   :: T+boxXYErrorBars :: T+financeBars    :: T+candleSticks   :: T+vectors        :: T+pm3d           :: T++lines          = Cons "lines"+points         = Cons "points"+linesPoints    = Cons "linespoints"+impulses       = Cons "impulses"+dots           = Cons "dots"+steps          = Cons "steps"+fSteps         = Cons "fsteps"+hiSteps        = Cons "histeps"+errorBars      = Cons "errorbars"+xErrorBars     = Cons "xerrorbars"+yErrorBars     = Cons "yerrorbars"+xyErrorBars    = Cons "xyerrorbars"+errorLines     = Cons "errorlines"+xErrorLines    = Cons "xerrorlines"+yErrorLines    = Cons "yerrorlines"+xyErrorLines   = Cons "xyerrorlines"+boxes          = Cons "boxes"+filledCurves   = Cons "filledcurves"+boxErrorBars   = Cons "boxerrorbars"+boxXYErrorBars = Cons "boxxyerrorbars"+financeBars    = Cons "financebars"+candleSticks   = Cons "candlesticks"+vectors        = Cons "vectors"+pm3d           = Cons "pm3d"+++toString :: T -> String+toString (Cons t) = t

@@ -0,0 +1,63 @@+module Graphics.Gnuplot.Private.LineSpecification where++import Data.Maybe (catMaybes, )+import Graphics.Gnuplot.Utility (quote, )+++{-+The Int types would be better enumerations+but their interpretations depend on the gnuplot output type. :-(+-}++data T =+   Cons+      { lineStyle_ :: Maybe Int+      , lineType_  :: Maybe Int+      , lineWidth_ :: Maybe Double+      , pointType_ :: Maybe Int+      , pointSize_ :: Maybe Double+      , title_     :: Maybe String+      }++deflt :: T+deflt =+   Cons+      { lineStyle_ = Nothing+      , lineType_  = Nothing+      , lineWidth_ = Nothing+      , pointType_ = Nothing+      , pointSize_ = Nothing+      , title_     = Nothing+      }++lineStyle :: Int -> T -> T+lineStyle x ls = ls{lineStyle_ = Just x}++lineType :: Int -> T -> T+lineType x ls = ls{lineType_ = Just x}++lineWidth :: Double -> T -> T+lineWidth x ls = ls{lineWidth_ = Just x}++pointType :: Int -> T -> T+pointType x ls = ls{pointType_ = Just x}++pointSize :: Double -> T -> T+pointSize x ls = ls{pointSize_ = Just x}++title :: String -> T -> T+title x ls = ls{title_ = Just x}+++toString :: T -> String+toString linespec =+   let showField :: String -> (a -> String) -> (T -> Maybe a) -> Maybe [String]+       showField s f access = fmap (\a -> [s, f a]) $ access linespec+   in  unwords $ concat $ catMaybes $+       showField "linetype"  show  lineType_  :+       showField "linewidth" show  lineWidth_ :+       showField "pointtype" show  pointType_ :+       showField "pointsize" show  pointSize_ :+       showField "title"     quote title_     :+       showField "linestyle" show  lineStyle_ :+       []

@@ -0,0 +1,86 @@+module Graphics.Gnuplot.Private.Plot where++import qualified Data.Monoid.State as State+import Data.Monoid (Monoid, mempty, mappend, )++import qualified Graphics.Gnuplot.Display as Display+import qualified Graphics.Gnuplot.Private.Graph as Graph+import Graphics.Gnuplot.Utility (quote, commaConcat, )++import Data.Maybe (mapMaybe, )+++{- |+Plots can be assembled using 'mappend' or 'mconcat'.+-}+newtype T graph = Cons (State.T Int [File graph])++{-+Could also be implemented with Control.Monad.Trans.State:+mappend = liftA2 mappend+-}+instance Monoid (T graph) where+   mempty = Cons mempty+   mappend (Cons s0) (Cons s1) =+      Cons (mappend s0 s1)+++withUniqueFile :: String -> [graph] -> T graph+withUniqueFile content graphs =+   Cons (State.Cons $ \n ->+      ([File (tmpFileStem ++ show n ++ ".csv") (Just content) graphs],+       succ n))++fromGraphs :: FilePath -> [graph] -> T graph+fromGraphs name gs =+   Cons (State.pure [File name Nothing gs])+++data File graph =+   File {+      filename_ :: FilePath,+      content_ :: Maybe String,+      graphs_ :: [graph]+   }++writeData :: File graph -> IO ()+writeData (File fn cont _) =+   maybe (return ()) (writeFile fn) cont+++tmpFileStem :: FilePath+tmpFileStem = "curve"++{-+tmpFile :: FilePath+tmpFile = tmpFileStem ++ ".csv"+-}+++instance Functor T where+   fmap f (Cons mp) =+      Cons $+      fmap (map (\file -> file{graphs_ = map f $ graphs_ file}))+      mp++instance Graph.C graph => Display.C (T graph) where+   toScript p@(Cons mp) =+      Display.Script $ State.Cons $+         \(n0, opts) ->+            let (blocks, n1) = State.run mp n0+                files =+                   mapMaybe+                      (\blk -> fmap (Display.File (filename_ blk)) (content_ blk))+                      blocks+                graphs =+                   concatMap (\blk ->+                      map (\gr -> quote (filename_ blk) ++ " " ++ Graph.toString gr) $ graphs_ blk) $+                      blocks+            in  (Display.Body files+                    [plotCmd p undefined ++ " " ++ commaConcat graphs],+                 (n1, opts))++plotCmd ::+   Graph.C graph =>+   T graph -> graph -> String+plotCmd _plot = Graph.command

@@ -1,3 +1,10 @@+{- |+This is a simple monolithic interface to gnuplot+that can be used as is in GHCi or Hugs.+We do not plan to support every feature of gnuplot here,+instead we provide an advanced modularized interface+in "Graphics.Gnuplot.Advanced".+-} module Graphics.Gnuplot.Simple (     Attribute(..),     Size(..),@@ -12,6 +19,8 @@     linearScale,     defaultStyle, +    terminal,+     plotList,     plotListStyle,     plotLists,@@ -36,23 +45,40 @@     inclPlot,   ) where -import System.Exit (ExitCode, )-import System.Cmd (rawSystem, )-import Control.Monad (zipWithM, )-import Data.Maybe (listToMaybe, mapMaybe, isNothing, )+import qualified Graphics.Gnuplot.Plot.TwoDimensional as Plot2D+import qualified Graphics.Gnuplot.Plot.ThreeDimensional as Plot3D+import qualified Graphics.Gnuplot.Private.LineSpecification as LineSpec+import qualified Graphics.Gnuplot.Private.Graph2D as Graph2D+import qualified Graphics.Gnuplot.Private.Graph3D as Graph3D+import qualified Graphics.Gnuplot.Private.GraphType as GraphType+import qualified Graphics.Gnuplot.Private.Plot as Plot++{-+import qualified Graphics.Gnuplot.Terminal.PostScript as PS+import qualified Graphics.Gnuplot.Terminal.PNG as PNG+import qualified Graphics.Gnuplot.Terminal.SVG as SVG+-}++import qualified Graphics.Gnuplot.Terminal as Terminal import qualified Graphics.Gnuplot.Execute as Exec++import System.Cmd (rawSystem, ) import Graphics.Gnuplot.Utility-   (functionToGraph,-    quote, commaConcat, showTriplet, )+   (quote, commaConcat, showTriplet, linearScale, )+import qualified Data.Monoid.State as State+import Data.Maybe (listToMaybe, mapMaybe, isNothing, ) import Data.List.HT (dropWhileRev, )+import Data.List (intersperse, )+import Data.Monoid (mconcat, )  -{-* User front-end -}+-- * User front-end  data Attribute =      Custom String [String]  -- ^ anything that is allowed after gnuplot's @set@ command    | EPS    FilePath    | PNG    FilePath+   | Terminal Terminal.T     -- ^ you cannot use this, call 'terminal' instead    | Grid   (Maybe [String])    | Key    (Maybe [String])    | Border (Maybe [String])@@ -123,88 +149,87 @@ data PlotStyle = PlotStyle { plotType :: PlotType, lineSpec :: LineSpec }  --- candidate for Useful, similar routines are in module Integration-linearScale :: Fractional a => Integer -> (a,a) -> [a]-linearScale n (x0,x1) =-   map (\m -> x0 + (x1-x0) * fromIntegral m / fromIntegral n) [0..n]  defaultStyle :: PlotStyle defaultStyle = PlotStyle Lines (CustomStyle [])  +terminal :: Terminal.C term => term -> Attribute+terminal =+   Terminal . Terminal.canonical ++-- * plot functions+ {- | > plotList [] (take 30 (let fibs = 0 : 1 : zipWith (+) fibs (tail fibs) in fibs)) -} plotList :: Show a => [Attribute] -> [a] -> IO ()-plotList attrs = plotListStyle attrs defaultStyle+plotList attrs =+   plot2d attrs . Plot2D.list  plotListStyle :: Show a => [Attribute] -> PlotStyle -> [a] -> IO ()-plotListStyle attrs style dat =-   do writeFile tmpFile (unlines (map show dat))-      callGnuplot attrs "plot"-                  [quote tmpFile ++ " using 1 " ++-                   plotStyleToString style]-      return ()+plotListStyle attrs style =+   plot2d attrs . setPlotStyle style . Plot2D.list  plotLists :: Show a => [Attribute] -> [[a]] -> IO ()-plotLists attrs = plotListsStyle attrs . map ((,) defaultStyle)+plotLists attrs xss =+   plot2d attrs (mconcat $ map Plot2D.list xss)  plotListsStyle :: Show a => [Attribute] -> [(PlotStyle, [a])] -> IO ()-plotListsStyle attrs dats =-   do fileNames <- zipWithM-         (\n dat ->-             let fileName = tmpFileStem ++ show n ++ ".dat"-             in  writeFile fileName-                           (unlines (map show dat))-                    >> return fileName)-         [(1::Int)..] (map snd dats)-      callGnuplot attrs "plot"-         (zipWith-            (\fileName style ->-               quote fileName ++ " using 1 " ++-                  plotStyleToString style)-            fileNames (map fst dats))-      return ()+plotListsStyle attrs =+   plot2d attrs . mconcat .+   map (\(style,xs) -> setPlotStyle style $ Plot2D.list xs)  {- | > plotFunc [] (linearScale 1000 (-10,10)) sin -} plotFunc :: Show a => [Attribute] -> [a] -> (a -> a) -> IO ()-plotFunc attrs args f = plotPath attrs (functionToGraph args f)+plotFunc attrs args f =+   plot2d attrs (Plot2D.function args f)  {- | > plotFuncs [] (linearScale 1000 (-10,10)) [sin, cos] -} plotFuncs :: Show a => [Attribute] -> [a] -> [a -> a] -> IO () plotFuncs attrs args fs =-   plot2dMultiSharedAbscissa attrs (zipWith const (repeat defaultStyle) fs)-      (map (\x -> (x, map ($ x) fs)) args)+   plot2d attrs (Plot2D.functions args fs)  plotPath :: Show a => [Attribute] -> [(a,a)] -> IO ()-plotPath attrs = plot2dGen attrs defaultStyle+plotPath attrs =+   plot2d attrs . Plot2D.path  plotPaths :: Show a => [Attribute] -> [[(a,a)]] -> IO ()-plotPaths attrs = plot2dMultiGen attrs . zip (repeat defaultStyle)+plotPaths attrs xss =+   plot2d attrs (mconcat $ map Plot2D.path xss)  plotPathStyle :: Show a => [Attribute] -> PlotStyle -> [(a,a)] -> IO ()-plotPathStyle = plot2dGen+plotPathStyle attrs style =+   plot2d attrs . setPlotStyle style . Plot2D.path  plotPathsStyle :: Show a => [Attribute] -> [(PlotStyle, [(a,a)])] -> IO ()-plotPathsStyle = plot2dMultiGen+plotPathsStyle attrs =+   plot2d attrs . mconcat .+   map (\(style,xs) -> setPlotStyle style $ Plot2D.path xs)  {- | > plotParamFunc [] (linearScale 1000 (0,2*pi)) (\t -> (sin (2*t), cos t)) -} plotParamFunc :: Show a => [Attribute] -> [a] -> (a -> (a,a)) -> IO ()-plotParamFunc attrs args f = plotPath attrs (map f args)+plotParamFunc attrs args f =+   plot2d attrs (Plot2D.parameterFunction args f) +{- |+> plotParamFuncs [] (linearScale 1000 (0,2*pi)) [\t -> (sin (2*t), cos t), \t -> (cos t, sin (2*t))]+-} plotParamFuncs :: Show a => [Attribute] -> [a] -> [a -> (a,a)] -> IO ()-plotParamFuncs attrs args fs = plotPaths attrs (map (flip map args) fs)+plotParamFuncs attrs args fs =+   plot2d attrs (mconcat $ map (Plot2D.parameterFunction args) fs)   plotDots :: Show a => [Attribute] -> [(a,a)] -> IO ()-plotDots attrs = plot2dGen attrs (defaultStyle { plotType = Dots })+plotDots attrs xs =+   plot2d attrs (fmap (Graph2D.typ GraphType.dots) $ Plot2D.path xs)   @@ -232,13 +257,7 @@ plotMesh3d :: (Show a, Show b, Show c) =>    [Attribute] -> [Attribute3d] -> [[(a,b,c)]] -> IO () plotMesh3d attrs pt dat =-   do writeFile tmpFile (unlines (map (unlines . map showTriplet) dat))-      Exec.simple-         (map attrToProg attrs ++-          ["set pm3d " ++ unwords (map attribute3dToString pt)] ++-          ["splot " ++ quote tmpFile ++ " using 1:2:3 with pm3"])-         ["-persist"]-      return ()+   plot3d attrs pt (Plot3D.mesh dat)  {- | > let xs = [-2,-1.8..2::Double] in plotFunc3d [] [] xs xs (\x y -> exp(-(x*x+y*y)))@@ -246,11 +265,11 @@ plotFunc3d :: (Show a, Show b, Show c) =>    [Attribute] -> [Attribute3d] -> [b] -> [c] -> (b -> c -> a) -> IO () plotFunc3d attrs pt xArgs yArgs f =-   plotMesh3d attrs pt (map (map (\(x,y) -> (x, y, f x y)) . flip map yArgs . (,)) xArgs)+   plot3d attrs pt (Plot3D.function xArgs yArgs f)   -{-* For inclusion of gnuplot graphics in LaTeX documents using lhs2TeX -}+-- * For inclusion of gnuplot graphics in LaTeX documents using lhs2TeX  {-| Redirects the output of a plotting function to an EPS file     and additionally converts it to PDF. -}@@ -281,24 +300,23 @@   -{-* Internal functions -}--tmpFileStem, tmpFile :: FilePath--tmpFileStem = "curve"-tmpFile = tmpFileStem ++ ".dat"-+-- * Internal functions  attrToProg :: Attribute -> String attrToProg (Custom attribute parameters) =    "set " ++ attribute ++ " " ++ unwords parameters +attrToProg (Terminal (Terminal.Cons options commands)) =+   concat $+   intersperse "; " $+   ("set terminal " ++ unwords options) : commands+ attrToProg (EPS filename) =-   "set terminal postscript eps;" ++  -- latex+   "set terminal postscript eps; " ++  -- latex    "set output " ++ quote filename  attrToProg (PNG filename) =-   "set terminal png;" ++  -- latex+   "set terminal png; " ++    "set output " ++ quote filename  attrToProg (Grid   (Just x))     = "set grid " ++ unwords x@@ -318,7 +336,8 @@ attrToProg (BoxAspect (Ratio r)) = "set size ratio " ++ show r attrToProg (BoxAspect (NoRatio)) = "set size noratio" attrToProg (LineStyle num style) =-   "set linestyle " ++ show num ++ " " ++ unwords (map lineAttrToString style)+   "set linestyle " ++ show num ++ " " +++   LineSpec.toString (lineAttrRecord style LineSpec.deflt) attrToProg (Title  title_)       = "set title " ++ quote title_ attrToProg (XLabel label)        = "set xlabel " ++ quote label attrToProg (YLabel label)        = "set ylabel " ++ quote label@@ -353,47 +372,33 @@   -lineAttrToString :: LineAttr -> String-lineAttrToString (LineType  t) = "linetype "  ++ show t-lineAttrToString (LineWidth x) = "linewidth " ++ show x-lineAttrToString (PointType t) = "pointtype " ++ show t-lineAttrToString (PointSize x) = "pointsize " ++ show x-lineAttrToString (LineTitle s) = "title "     ++ quote s--lineSpecToString :: LineSpec -> String-lineSpecToString (DefaultStyle n) = "linestyle " ++ show n-lineSpecToString (CustomStyle  s) = unwords (map lineAttrToString s)--plotTypeToString :: PlotType -> String-plotTypeToString Lines          = "lines"-plotTypeToString Points         = "points"-plotTypeToString LinesPoints    = "linespoints"-plotTypeToString Impulses       = "impulses"-plotTypeToString Dots           = "dots"-plotTypeToString Steps          = "steps"-plotTypeToString FSteps         = "fsteps"-plotTypeToString HiSteps        = "histeps"-plotTypeToString ErrorBars      = "errorbars"-plotTypeToString XErrorBars     = "xerrorbars"-plotTypeToString YErrorBars     = "yerrorbars"-plotTypeToString XYErrorBars    = "xyerrorbars"-plotTypeToString ErrorLines     = "errorlines"-plotTypeToString XErrorLines    = "xerrorlines"-plotTypeToString YErrorLines    = "yerrorlines"-plotTypeToString XYErrorLines   = "xyerrorlines"-plotTypeToString Boxes          = "boxes"-plotTypeToString FilledCurves   = "filledcurves"-plotTypeToString BoxErrorBars   = "boxerrorbars"-plotTypeToString BoxXYErrorBars = "boxxyerrorbars"-plotTypeToString FinanceBars    = "financebars"-plotTypeToString CandleSticks   = "candlesticks"-plotTypeToString Vectors        = "vectors"-plotTypeToString PM3d           = "pm3d"---plotStyleToString :: PlotStyle -> String-plotStyleToString (PlotStyle p l) =-   "with " ++ plotTypeToString p ++ " " ++ lineSpecToString l+plotTypeToGraph :: PlotType -> GraphType.T+plotTypeToGraph t =+   case t of+      Lines          -> GraphType.lines+      Points         -> GraphType.points+      LinesPoints    -> GraphType.linesPoints+      Impulses       -> GraphType.impulses+      Dots           -> GraphType.dots+      Steps          -> GraphType.steps+      FSteps         -> GraphType.fSteps+      HiSteps        -> GraphType.hiSteps+      ErrorBars      -> GraphType.errorBars+      XErrorBars     -> GraphType.xErrorBars+      YErrorBars     -> GraphType.yErrorBars+      XYErrorBars    -> GraphType.xyErrorBars+      ErrorLines     -> GraphType.errorLines+      XErrorLines    -> GraphType.xErrorLines+      YErrorLines    -> GraphType.yErrorLines+      XYErrorLines   -> GraphType.xyErrorLines+      Boxes          -> GraphType.boxes+      FilledCurves   -> GraphType.filledCurves+      BoxErrorBars   -> GraphType.boxErrorBars+      BoxXYErrorBars -> GraphType.boxXYErrorBars+      FinanceBars    -> GraphType.financeBars+      CandleSticks   -> GraphType.candleSticks+      Vectors        -> GraphType.vectors+      PM3d           -> GraphType.pm3d   plot3dTypeToString :: Plot3dType -> String@@ -415,43 +420,51 @@    "corners2color " ++cornersToColorToString c2c  -{-| Writes point data to a file and returns a string containing-    Gnuplot.plot parameters to invoke the file. -}-storeData :: Show a => FilePath -> PlotStyle -> [(a,a)] -> IO String-storeData file style dat =-   do writeFile file (unlines (map (\(x,y) -> show x ++ " " ++ show y) dat))-      return (quote file ++ " using 1:2 " ++ plotStyleToString style) -plot2dGen :: Show a => [Attribute] -> PlotStyle -> [(a,a)] -> IO ()-plot2dGen attrs style dat =-   do plotParam <- storeData tmpFile style dat-      callGnuplot attrs "plot" [plotParam]-      return ()+plot2d :: [Attribute] -> Plot2D.T -> IO ()+plot2d attrs (Plot.Cons mp) =+   let files = State.evaluate 0 mp+   in  do mapM_ Plot.writeData files+          callGnuplot attrs "plot" $+             concatMap (\(Plot.File filename _ grs) ->+                map (\gr -> quote filename ++ " " ++ Graph2D.toString gr) grs) $+             files -plot2dMultiGen :: Show a =>-   [Attribute] -> [(PlotStyle, [(a,a)])] -> IO ()-plot2dMultiGen attrs styleDat =-   do plotParams <- sequence $-         zipWith (\n -> uncurry (storeData (tmpFileStem++show n++".dat")))-                 [(0::Int)..] styleDat-      callGnuplot attrs "plot" plotParams-      return ()+setPlotStyle :: PlotStyle -> Plot2D.T -> Plot2D.T+setPlotStyle ps =+   fmap (Graph2D.typ (plotTypeToGraph $ plotType ps) .+         Graph2D.lineSpec (lineSpecRecord $ lineSpec ps)) -plot2dMultiSharedAbscissa :: Show a =>-   [Attribute] -> [PlotStyle] -> [(a,[a])] -> IO ()-plot2dMultiSharedAbscissa attrs styles dat =-   let plotParams =-          zipWith (\n style -> quote tmpFile ++ " using 1:"-                       ++ show (n+1) ++ " " ++ plotStyleToString style)-                  [(1::Int)..] styles-   in  do {- writeFile tmpFile (concatMap (\(x,ys) ->-             foldr (\y -> shows y . (' ':)) (shows x "\n") ys) dat) -}-          writeFile tmpFile-             (unlines (map (unwords . map show . uncurry (:)) dat))-          callGnuplot attrs "plot" plotParams-          return () -callGnuplot :: [Attribute] -> String -> [String] -> IO ExitCode+plot3d :: [Attribute] -> [Attribute3d] -> Plot3D.T -> IO ()+plot3d attrs pt (Plot.Cons mp) =+   let files = State.evaluate 0 mp+   in  do mapM_ Plot.writeData files+          callGnuplot+             (attrs ++ [Custom "pm3d" (map attribute3dToString pt)]) "splot" $+             concatMap (\(Plot.File filename _ grs) ->+                map (\gr -> quote filename ++ " " ++ Graph3D.toString gr) grs) $+             files+++lineSpecRecord :: LineSpec -> LineSpec.T+lineSpecRecord (DefaultStyle n) =+   LineSpec.lineStyle n LineSpec.deflt+lineSpecRecord (CustomStyle ls) =+   lineAttrRecord ls LineSpec.deflt++lineAttrRecord :: [LineAttr] -> LineSpec.T -> LineSpec.T+lineAttrRecord =+   flip $ foldl (flip $ \attr ->+      case attr of+         LineType  n -> LineSpec.lineType  n+         LineWidth w -> LineSpec.lineWidth w+         PointType n -> LineSpec.pointType n+         PointSize s -> LineSpec.pointSize s+         LineTitle s -> LineSpec.title     s+      )++callGnuplot :: [Attribute] -> String -> [String] -> IO () callGnuplot attrs cmd params =    Exec.simple       (map attrToProg attrs ++@@ -460,3 +473,4 @@         commaConcat params])       ["-persist"]    -- instead of the option, one can also use 'set terminal x11 persist'+     >> return ()

@@ -0,0 +1,18 @@+module Graphics.Gnuplot.Terminal where++data T =+   Cons {+      options :: [String],+      commands :: [String]+   }++class C terminal where+   canonical :: terminal -> T++deflt :: T+deflt = Cons ["x11"] []+++formatBool :: String -> Bool -> String+formatBool name b =+   if b then name else "no"++name

@@ -0,0 +1,91 @@+module Graphics.Gnuplot.Terminal.PNG (+   T, cons,+   transparent, noTransparent,+   interlace, noInterlace,+   trueColor, noTrueColor,+   fontTiny, fontSmall, fontMedium, fontLarge, fontGiant,+   ) where++import qualified Graphics.Gnuplot.Terminal as Terminal+import Graphics.Gnuplot.Terminal (formatBool, )+import Data.Maybe (catMaybes, )+import Graphics.Gnuplot.Utility (quote, )+++data T =+   Cons {+      filename_ :: FilePath,+      transparent_ :: Maybe Bool,+      interlace_ :: Maybe Bool,+      trueColor_ :: Maybe Bool,+      fontSize_ :: Maybe FontSize+   }++cons :: FilePath -> T+cons path =+   Cons {+      filename_ = path,+      transparent_ = Nothing,+      interlace_ = Nothing,+      trueColor_ = Nothing,+      fontSize_ = Nothing+   }++++transparent, noTransparent :: T -> T+transparent   term = term{transparent_ = Just True}+noTransparent term = term{transparent_ = Just False}++interlace, noInterlace :: T -> T+interlace   term = term{interlace_ = Just True}+noInterlace term = term{interlace_ = Just False}++trueColor, noTrueColor :: T -> T+trueColor   term = term{trueColor_ = Just True}+noTrueColor term = term{trueColor_ = Just False}++++fontTiny, fontSmall, fontMedium, fontLarge, fontGiant :: T -> T+fontTiny   = setFontSize FontTiny+fontSmall  = setFontSize FontSmall+fontMedium = setFontSize FontMedium+fontLarge  = setFontSize FontLarge+fontGiant  = setFontSize FontGiant++++-- private functions++data FontSize =+   FontTiny | FontSmall | FontMedium | FontLarge | FontGiant++formatFontSize :: FontSize -> String+formatFontSize size =+   case size of+      FontTiny   -> "tiny"+      FontSmall  -> "small"+      FontMedium -> "medium"+      FontLarge  -> "large"+      FontGiant  -> "giant"++setFontSize :: FontSize -> T -> T+setFontSize size term =+   term{fontSize_ = Just size}+++instance Terminal.C T where+   canonical term =+      Terminal.Cons {+         Terminal.options =+            "png" :+            catMaybes (+               (fmap (formatBool "transparent") $ transparent_ term) :+               (fmap (formatBool "interlace") $ interlace_ term) :+               (fmap (formatBool "truecolor") $ trueColor_ term) :+               (fmap formatFontSize $ fontSize_ term) :+               []),+         Terminal.commands =+            ["set output " ++ (quote $ filename_ term)]+      }

@@ -0,0 +1,76 @@+module Graphics.Gnuplot.Terminal.PostScript (+   T, cons,+   landscape, portrait, eps,+   color, monochrome,+   ) where++import qualified Graphics.Gnuplot.Terminal as Terminal+import Data.Maybe (catMaybes, )+import Graphics.Gnuplot.Utility (quote, )+++data T =+   Cons {+      filename_ :: FilePath,+      mode_ :: Maybe Mode,+      color_ :: Maybe Bool+   }++cons :: FilePath -> T+cons path =+   Cons {+      filename_ = path,+      mode_ = Nothing,+      color_ = Nothing+   }+++landscape :: T -> T+landscape = setMode Landscape++portrait :: T -> T+portrait = setMode Portrait++eps :: T -> T+eps = setMode EPS+++color :: T -> T+color term =+   term{color_ = Just True}++monochrome :: T -> T+monochrome term =+   term{color_ = Just False}+++-- private functions++data Mode =+     Landscape+   | Portrait+   | EPS++formatMode :: Mode -> String+formatMode mode =+   case mode of+      Landscape -> "landscape"+      Portrait  -> "portrait"+      EPS       -> "eps"++setMode :: Mode -> T -> T+setMode mode term = term{mode_ = Just mode}+++instance Terminal.C T where+   canonical term =+      Terminal.Cons {+         Terminal.options =+            "postscript" :+            catMaybes (+               (fmap formatMode $ mode_ term) :+               (fmap (\b -> if b then "color" else "monochrome") $ color_ term) :+               []),+         Terminal.commands =+            ["set output " ++ (quote $ filename_ term)]+      }

@@ -0,0 +1,32 @@+module Graphics.Gnuplot.Terminal.SVG (+   T, cons,+   ) where++import qualified Graphics.Gnuplot.Terminal as Terminal+import Graphics.Gnuplot.Utility (quote, )+++data T =+   Cons {+      filename_ :: FilePath+   }++cons :: FilePath -> T+cons path =+   Cons {+      filename_ = path+   }++++-- private functions++instance Terminal.C T where+   canonical term =+      Terminal.Cons {+         Terminal.options =+            "svg" :+            [],+         Terminal.commands =+            ["set output " ++ (quote $ filename_ term)]+      }

@@ -0,0 +1,49 @@+module Graphics.Gnuplot.Terminal.X11 (+   T, cons,+   title, noTitle,+   persist, noPersist,+   ) where++import qualified Graphics.Gnuplot.Terminal as Terminal+import Graphics.Gnuplot.Terminal (formatBool, )+import Data.Maybe (catMaybes, )+import Graphics.Gnuplot.Utility (quote, )+++data T =+   Cons {+      title_ :: Maybe String,+      persist_ :: Maybe Bool+   }++cons :: T+cons =+   Cons {+      title_ = Nothing,+      persist_ = Nothing+   }+++title :: String -> T -> T+title text term = term{title_ = Just text}++noTitle :: T -> T+noTitle term = term{title_ = Nothing}++persist, noPersist :: T -> T+persist   term = term{persist_ = Just True}+noPersist term = term{persist_ = Just False}+++instance Terminal.C T where+   canonical term =+      Terminal.Cons {+         Terminal.options =+            "x11" :+            catMaybes (+               (fmap quote $ title_ term) :+               (fmap (formatBool "persist") $ persist_ term) :+               []),+         Terminal.commands =+            []+      }

@@ -8,6 +8,11 @@ -- functionToGraph args f = map swap $ attachKey f args  +linearScale :: Fractional a => Integer -> (a,a) -> [a]+linearScale n (x0,x1) =+   map (\m -> x0 + (x1-x0) * fromIntegral m / fromIntegral n) [0..n]++ showTriplet :: (Show a, Show b, Show c) => (a,b,c) -> String showTriplet (x,y,z) = unwords [show x, show y, show z]